package com.zgc.demo.ftzf.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;

@RestController
@RequestMapping("/flux")
public class FluxTestController {

    public static void main(String[] args) {


        // 生成简单序列

        Flux.just("Hello", "World").subscribe(System.out::println);
        Flux.fromArray(new Integer[] {1, 2, 3}).subscribe(System.out::println);
        Flux.empty().subscribe(System.out::println);
        Flux.range(1, 10).subscribe(System.out::println);
        Flux.interval(Duration.of(10, ChronoUnit.SECONDS)).subscribe(System.out::println);

        // 生成复杂序列
        Flux.generate(sink -> {
            // 当Flux处理序列的时候，每个序列都会被调用的函方法
            sink.next("生成一个值");
            // 调用结束序列的方法
            sink.complete();
        }).subscribe(System.out::println);


        // 复杂序列

        // generate 创建序列
        final Random random = new Random();
        Flux.generate(ArrayList::new, (list, sink) -> {
            int value = random.nextInt(100);
            list.add(value);
            sink.next(value);
            if (list.size() == 10) {
                sink.complete();
            }
            return list;
        }).subscribe(System.out::println);

        // create 创建序列
        Flux.create(sink -> {
            for (int i = 0; i < 10; i++) {
                sink.next(i);
            }
            sink.complete();
        }).subscribe(System.out::println);


    }

    // flux 静态方法案列

    /**
     * 可以指定序列中包含的全部元素。创建出来的 Flux 序列在发布这些元素之后会自动结束。
     *
     * @return
     */
    @GetMapping("/just")
    public Flux just() {
        return Flux.just("123", "456", "789");
    }

    /**
     * fromArray()，fromIterable()和 fromStream()
     * 从一个数组、Iterable 对象或 Stream 对象中创建 Flux 对象。
     */
    public void from() {
        // 从数组
        final Flux<Object> flux = Flux.fromArray(Arrays.asList(1, 2, 3, 4, 5, 6).toArray());
        // 从Stream
        final Flux<Integer> flux1 = Flux.fromStream(Arrays.asList(1, 2, 3, 4, 5, 6).stream());
        // 从迭代器或者集合对象（继承迭代器接口的集合对象）
        final Flux<Integer> tFlux = Flux.fromIterable(Arrays.asList(1, 2, 3, 4, 5, 6));
    }

    /**
     * 创建一个不包含任何元素，只发布结束消息的序列。
     *
     * @return
     */
    @GetMapping("/empty")
    public Flux empty() {
        return Flux.empty();
    }

    /**
     * 创建一个只包含错误消息的序列。
     *
     * @return
     */
    @GetMapping("/error")
    public Flux error() {
        return Flux.error(new RuntimeException());
    }

    /**
     * 创建一个不包含任何消息通知的序列。
     * 因为不像其他接口会调用结束序列，所以这样会一直挂着。
     *
     * @return
     */
    @GetMapping("/never")
    public Flux never() {
        return Flux.never();
    }

    /**
     * 创建包含从 start 起始的 count 个数量的 Integer 对象的序列。
     *
     * @return
     */
    @GetMapping("/range")
    public Flux range() {
        return Flux.range(18888,20);
    }


}
